diff --git a/system/database/DB_active_rec.php b/system/database/DB_active_rec.php
index d79a068..82d5b63 100644
--- a/system/database/DB_active_rec.php
+++ b/system/database/DB_active_rec.php
@@ -405,7 +405,7 @@
 	{
 		if (trim($direction) != '')
 		{
-			$direction = (in_array(strtoupper(trim($direction)), array('ASC', 'DESC', 'RAND()'), TRUE)) ? ' '.$direction : ' ASC';
+			$direction = (in_array(strtoupper(trim($direction)), array('ASC', 'DESC'), TRUE)) ? ' '.$direction : ' ASC';
 		}
 		
 		$this->ar_orderby[] = $orderby.$direction;
diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 730bfa3..d03fab5 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -70,6 +70,7 @@
 	<li>Added <dfn>$assign_to_controller</dfn> variable in the main <kbd>index.php</kbd> file.  Anything that this variable contains will be passed automatically to a controller constructor when initialized.</li>
 	<li>Reorganized the URI and Routes classes for better clarity.</li>
     <li>Javascript Calendar plugin now uses the months and days from the calendar language file, instead of hard-coded values, internationalizing it </li>
+    <li>Removed &quot;rand()&quot; as a listed option from orderby in the <a href="./database/active_record.html">Active Record</a>, as it was MySQL only. </li>
     <li>Added titles to all user manual pages </li>
     <li>Fixed a bug in database driver where num_rows property wasn't getting updated </li>
     <li>Fixed a bug in captcha calling an invalid PHP function</li>
diff --git a/user_guide/database/active_record.html b/user_guide/database/active_record.html
index 37629ae..504f183 100644
--- a/user_guide/database/active_record.html
+++ b/user_guide/database/active_record.html
@@ -354,7 +354,7 @@
 	
 <h2>$this->db->orderby();</h2>
 <p>Lets you set an ORDER BY clause. The first parameter contains the name of the column you would like to order by.
-The second parameter lets you set the direction of the result.  Options are <kbd>asc</kbd> or <kbd>desc</kbd> or <kbd>RAND()</kbd></p>
+The second parameter lets you set the direction of the result.  Options are <kbd>asc</kbd> or <kbd>desc</kbd></p>
 	
 <code>$this->db->orderby("title", "desc");
 <br /><br />// Produces: ORDER BY title DESC
